package org.jaaksi.kottlindemo.test

import org.jaaksi.kottlindemo.model.OutClass
import org.jaaksi.kottlindemo.model.OutClass.cls

class Test1 {
  var list = arrayListOf(1, 2, 3)

  // Koltin中属性在声明的同时也要求要被初始化，否则会报错。
  // 但有时候，我们并不想声明一个类型可空的对象，而且也不能在声明的时候就为它初始化，那么这时就需要用到Kotlin提供的延迟初始化。
  // lateinit var只能用来修饰类属性，不能用来修饰局部变量，并且只能用来修饰对象，不能用来修饰基本类型(因为基本类型的属性在类加载后的准备阶段都会被初始化为默认值)。
  lateinit var bulu: String

  val xixi by lazy { // by lazy必须是val
    "111"
  }

  init {
    bulu = "111"
  }

  fun testwhen(x: Any) {
    when (x) {
      1 -> print("x == 1")
      2 -> print("x == 2")
      3, 4 -> print("x == 3 or x == 4")
      in 5..9 -> print("x in [5..9]")
      is Long -> print("x is Long")
      !in 10..20 -> print("x is outside the range")
      x is String -> print("$x is String")
      Integer.parseInt((x as? String) ?: "0") -> print("s encodes x")
      else -> { // Note the block
        print("x is funny")
      }
    }
  }

  fun testArray() {
    val array = arrayListOf(1, 2, 3, 4) // arrayOf
    for (i in array) {
      println(i)
    }
    for (i in array.indices) {
      println(array[i])
    }
    array.indexOfFirst {
      it == 3
    }
    val data: Int? = array.find {
      it > 2
    }
    array.filter {
      it > 2
    }
    array.apply {

    }


    array.forEachIndexed { index, value ->
      print("array[$index]=$value")
    }

    for ((index, value) in array.withIndex()) {
      println("the element at $index is $value")
    }

    val map = hashMapOf("1" to 1, "2" to 2, "3" to 3)
    for (key in map.keys) {
      println(key)
    }
    for (value in map.values) {
      println(value)
    }
    for ((key, value) in map) {
      println("the key at $key is $value")
    }
  }

  fun t3() {
    var name: String? = null
    var dd: String = name ?: "11" // Elvis操作符

    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits
      .filter { it.startsWith("a") }
      .sortedBy { it }
      .map { it.toUpperCase() }
      .forEach { println(it) }
  }

  fun t2() {

    // 结构相等（==）：默认会调用equal方法（如果不重写equal方法，Any默认的equal方法好像是判断引用是否相等）
    // 注意：结构相等对于null也是安全的，编译器会作null检查，如果都是null则返回true。
    // 引用相等（===）：判断饮用指向的是否是同一实例
    // internal
    OutClass().Inner().fun1()
    cls().fun1()
  }

  fun t1() {
    if (1 in list) {
      print("1 exist")
    }
    val filter = list.filter {
      it > 2
    }
    list.let {

    }

//    button.setOnClickListener({ view: View ->
//      view.visibility = View.GONE
//    })
  }

}